// proxy-server.js
const http = require('http');
const https = require('https');
const url = require('url');
const os = require('os');

// 创建HTTP服务器
const server = http.createServer(async (req, res) => {
    // 允许跨域请求
    res.setHeader('Access-Control-Allow-Origin', '*');
    res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
    res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
    
    // 处理预检请求
    if (req.method === 'OPTIONS') {
        res.writeHead(204);
        res.end();
        return;
    }
    
    // 只处理POST请求到/proxy路径
    if (req.method === 'POST' && req.url === '/proxy') {
        let body = '';
        
        // 设置请求体大小限制
        req.on('data', chunk => {
            body += chunk;
            // 限制请求体大小为1MB
            if (body.length > 1e6) {
                req.socket.destroy();
                res.writeHead(413, { 'Content-Type': 'application/json' });
                res.end(JSON.stringify({ error: '请求体过大' }));
            }
        });
        
        // 处理完成的请求
        req.on('end', () => {
            try {
                const proxyConfig = JSON.parse(body);
                
                // 验证URL参数
                if (!proxyConfig.url) {
                    res.writeHead(400, { 'Content-Type': 'application/json' });
                    res.end(JSON.stringify({ error: '缺少目标URL' }));
                    return;
                }
                
                const parsedUrl = url.parse(proxyConfig.url);
                
                // 仅允许HTTP和HTTPS协议
                if (parsedUrl.protocol !== 'http:' && parsedUrl.protocol !== 'https:') {
                    res.writeHead(400, { 'Content-Type': 'application/json' });
                    res.end(JSON.stringify({ error: '仅支持HTTP和HTTPS协议' }));
                    return;
                }
                
                // 配置代理请求选项
                const options = {
                    hostname: parsedUrl.hostname,
                    port: parsedUrl.port || (parsedUrl.protocol === 'https:' ? 443 : 80),
                    path: parsedUrl.path,
                    method: proxyConfig.method || 'GET',
                    headers: proxyConfig.headers || {}
                };
                
                // 设置超时时间
                const proxyReq = (parsedUrl.protocol === 'https:' ? https : http).request(options, (proxyRes) => {
                    // 设置响应头
                    res.writeHead(proxyRes.statusCode, proxyRes.headers);
                    
                    // 转发响应数据
                    proxyRes.on('data', (chunk) => {
                        res.write(chunk);
                    });
                    
                    // 响应结束
                    proxyRes.on('end', () => {
                        res.end();
                    });
                });
                
                // 设置超时时间
                proxyReq.setTimeout(10000, () => {
                    proxyReq.abort();
                    res.writeHead(408, { 'Content-Type': 'application/json' });
                    res.end(JSON.stringify({ error: '请求超时' }));
                });
                
                // 处理代理请求错误
                proxyReq.on('error', (err) => {
                    console.error('代理请求错误:', err);
                    res.writeHead(500, { 'Content-Type': 'application/json' });
                    res.end(JSON.stringify({ error: '代理请求失败', details: err.message }));
                });
                
                // 如果有请求体数据，则写入
                if (proxyConfig.body) {
                    proxyReq.write(proxyConfig.body);
                }
                
                // 结束代理请求
                proxyReq.end();
                
            } catch (err) {
                console.error('解析请求错误:', err);
                res.writeHead(400, { 'Content-Type': 'application/json' });
                res.end(JSON.stringify({ error: '无效的请求格式', details: err.message }));
            }
        });
    } else {
        // 处理其他请求
        res.writeHead(404, { 'Content-Type': 'application/json' });
        res.end(JSON.stringify({ error: '未找到请求的资源' }));
    }
});

// 启动服务器
const PORT = 9999;
server.listen(PORT, '0.0.0.0', () => {
    const interfaces = os.networkInterfaces();
    console.log(`代理服务器已启动，监听端口 ${PORT}`);
    console.log(`本地地址: http://127.0.0.1:${PORT}`);
    
    // 输出所有可用的网络地址
    Object.keys(interfaces).forEach(interfaceName => {
        interfaces[interfaceName].forEach(interfaceInfo => {
            if (!interfaceInfo.internal && interfaceInfo.family === 'IPv4') {
                console.log(`外部地址: http://${interfaceInfo.address}:${PORT}`);
            }
        });
    });
});